import { Router, Request, Response } from 'express';
import { spawn, ChildProcess } from 'child_process';
import path from 'path';
import multer from 'multer';
import { fileDB } from '../db/fileDB';
import os from 'os';
import { wsServer } from '../app';
import * as XLSX from 'xlsx';
import fs from 'fs';

const router = Router();

// 广播消息到所有WebSocket客户端
function sendToWebSocket(message: string) {
    if (wsServer && wsServer.clients && wsServer.clients.size > 0) {
        wsServer.clients.forEach((client: any) => {
            if (client.readyState === 1) { // 1 = WebSocket.OPEN
                try {
                    client.send(JSON.stringify({
                        type: 'python_output',
                        timestamp: new Date().toISOString(),
                        message: message
                    }));
                } catch (error) {
                    console.error('发送 WebSocket 消息失败:', error);
                }
            }
        });
    } else {
        console.warn('没有可用的 WebSocket 客户端');
    }
}

// 获取系统桌面路径
function getDesktopPath(): string {
    const platform = process.platform;
    if (platform === 'win32') {
        // Windows 系统
        return path.join(process.env.USERPROFILE || '', 'Desktop');
    } else if (platform === 'linux') {
        // Linux 系统
        return path.join(os.homedir(), '桌面');
    } else if (platform === 'darwin') {
        // macOS 系统
        return path.join(os.homedir(), 'Desktop');
    } else {
        throw new Error('不支持的操作系统');
    }
}

// 配置 multer 存储
const storage = multer.diskStorage({
    destination: function (req, file, cb) {
        try {
            const desktopPath = getDesktopPath();
            cb(null, desktopPath);
        } catch (error) {
            cb(error as Error, '');
        }
    },
    filename: function (req, file, cb) {
        // 保留原始文件名
        cb(null, file.originalname);
    }
});

// 文件过滤器
const fileFilter = (req: Express.Request, file: Express.Multer.File, cb: multer.FileFilterCallback) => {
    // 只接受视频文件
    if (file.mimetype.startsWith('video/') || file.mimetype.startsWith('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')) {
        cb(null, true);
    } else {
        cb(new Error('只允许上传视频文件或EXCEL文件'));
    }
};

// 配置 multer
const upload = multer({
    storage: storage,
    fileFilter: fileFilter,
    limits: {
        fileSize: 10 * 1024 * 1024 * 1024, // 10GB
        fieldSize: 10 * 1024 * 1024 * 1024 // 10GB
    }
});

// 上传视频路由
router.post('/upload', upload.single('file'), (req: Request & { file?: Express.Multer.File }, res: Response) => {
    try {
        if (!req.file) {
            return res.status(400).json({
                success: false,
                message: '没有上传文件'
            });
        }

        // 使用数据库模块添加记录
        const record = fileDB.addUpload(req.file.originalname, req.file.path);

        res.json({
            success: true,
            message: '文件上传成功',
            data: {
                filename: record.filename,
                path: record.path,
                uploadTime: record.uploadTime,
                size: req.file.size
            }
        });
    } catch (error) {
        // 处理文件大小超限错误
        if (error instanceof multer.MulterError) {
            if (error.code === 'LIMIT_FILE_SIZE') {
                return res.status(413).json({
                    success: false,
                    message: '文件大小超过限制',
                    error: '文件大小不能超过10GB'
                });
            }
        }
        
        res.status(500).json({
            success: false,
            message: '文件上传失败',
            error: error instanceof Error ? error.message : '未知错误'
        });
    }
});

// 开始检测路由
// 保存 Python 进程的引用
let pythonProcess: ChildProcess | null = null;
router.post('/begin', async (req: Request, res: Response) => {
    // 检测站点
    let station = req.body.station;
    // 检测车次
    let trainNumber = req.body.trainNumber;
    // 获取最新的上传记录
    const latestUpload = fileDB.getLatestUpload();
    if (!latestUpload) {
        return res.status(400).json({
            success: false,
            message: '没有找到上传的视频文件，请先上传视频'
        });
    }
    
    // 检测视频路径
    let videoPath = latestUpload.path;

    try {
        // 如果已经有进程在运行，先停止它
        if (pythonProcess) {
            pythonProcess.kill();
            pythonProcess = null;
        }

        // 建立 WebSocket 连接
        // 移除ws客户端相关的connectWebSocket、wsClient等实现

        // 获取桌面路径
        const desktopPath = getDesktopPath();
        const pythonScriptPath = path.join(desktopPath, 'main.py');
        
        console.log('video_path:', videoPath);
        console.log('start_position:', station);
        console.log('train_num:', trainNumber);
        console.log('Python script path:', pythonScriptPath);

        // 启动 Python 进程，传入参数
        pythonProcess = spawn('python', [
            pythonScriptPath,
            '--video_path', videoPath,
            '--start_position', station,
            '--train_num', trainNumber
        ]);

        // 处理 Python 脚本的输出
        if (pythonProcess.stdout) {
            pythonProcess.stdout.on('data', (data) => {
                // console.log(`Python 输出: ${data.toString('utf-8')}`);
                sendToWebSocket(`Python 输出: ${data.toString('utf-8')}`);
            });
        }

        // 处理 Python 脚本的错误
        if (pythonProcess.stderr) {
            pythonProcess.stderr.on('data', (data) => {
                console.error(`Python 错误: ${data.toString('utf-8')}`);
                sendToWebSocket(`Python 错误: ${data.toString('utf-8')}`);
            });
        }

        // 等待进程启动成功
        pythonProcess.on('spawn', () => {
            // 示例响应
            res.json({
                success: true,
                message: '检测已开始',
                data: {
                    startTime: new Date().toISOString(),
                    pythonScriptPath: pythonScriptPath,
                    videoPath: videoPath,
                    station: station,
                    trainNumber: trainNumber
                }
            });
        });

        // 处理 Python 进程的关闭
        pythonProcess.on('close', (code) => {
            console.log(`Python 进程退出，退出码: ${code}`);
            sendToWebSocket(`Python 进程退出，退出码: ${code}`);
            pythonProcess = null;
            
            // 关闭 WebSocket 连接
            // 移除ws客户端相关的connectWebSocket、wsClient等实现
        });

        // 处理启动错误
        pythonProcess.on('error', (error) => {
            console.error('启动 Python 进程失败:', error);
            sendToWebSocket(`启动 Python 进程失败: ${error.message}`);
            res.status(500).json({
                success: false,
                message: '启动检测失败',
                error: error.message
            });
        });
    } catch (error) {
        res.status(500).json({
            success: false,
            message: '启动检测失败',
            error: error instanceof Error ? error.message : '未知错误'
        });
    }
});

// 停止检测路由
router.post('/stop', (req: Request, res: Response) => {
    try {
        if (pythonProcess) {
            sendToWebSocket('正在停止检测进程...');
            
            // 在 Windows 上使用 taskkill 强制结束进程
            if (process.platform === 'win32' && pythonProcess.pid) {
                spawn('taskkill', ['/pid', pythonProcess.pid.toString(), '/f', '/t']);
            } else {
                // 在 Unix 系统上使用 kill 命令
                pythonProcess.kill('SIGTERM');
            }
            pythonProcess = null;
            
            sendToWebSocket('检测进程已停止');
            
            res.json({
                success: true,
                message: '检测已停止',
                data: {
                    stopTime: new Date().toISOString()
                }
            });
        } else {
            res.json({
                success: false,
                message: '没有正在运行的检测进程'
            });
        }
    } catch (error) {
        sendToWebSocket(`停止检测失败: ${error instanceof Error ? error.message : '未知错误'}`);
        res.status(500).json({
            success: false,
            message: '停止检测失败',
            error: error instanceof Error ? error.message : '未知错误'
        });
    }
});

// 解析Excel文件路由
let pythonProcessExcel: ChildProcess | null = null;
router.post('/fix', upload.single('file'), (req: Request & { file?: Express.Multer.File }, res: Response) => {
    try {
        if (!req.file) {
            return res.status(400).json({
                success: false,
                message: '没有上传EXCEL文件'
            });
        }
        
        const fileName = req.file.originalname;

        // 使用数据库模块添加记录
        const record = fileDB.addUpload(req.file.originalname, req.file.path);

        try {
            // 如果已经有进程在运行，先停止它
            if (pythonProcessExcel) {
                pythonProcessExcel.kill();
                pythonProcessExcel = null;
            }

    
            // 获取桌面路径
            const desktopPath = getDesktopPath();
            const pythonScriptPath = path.join(desktopPath, 'dataFix.py');
            console.log(record.path)
    
            // 启动 Python 进程，传入参数
            pythonProcessExcel = spawn('python', [
                pythonScriptPath,
                '--export_path', record.path
            ]);
    
            // 处理 Python 脚本的输出
            if (pythonProcessExcel.stdout) {
                pythonProcessExcel.stdout.on('data', (data) => {
                    console.log(`Python 输出: ${data.toString('utf-8')}`);
                    sendToWebSocket(`Python 输出: ${data.toString('utf-8')}`);
                });
            }
    
            // 处理 Python 脚本的错误
            if (pythonProcessExcel.stderr) {
                pythonProcessExcel.stderr.on('data', (data) => {
                    console.error(`Python 错误: ${data.toString('utf-8')}`);
                    sendToWebSocket(`Python 错误: ${data.toString('utf-8')}`);
                });
            }
    
            // 等待进程启动成功
            pythonProcessExcel.on('spawn', () => {
                // 示例响应
                console
            });
    
            // 处理 Python 进程的关闭
            pythonProcessExcel.on('close', (code) => {
                // console.log(`Python 进程退出，退出码: ${code}`);
                sendToWebSocket(`Python 进程退出，退出码: ${code}`);
                pythonProcessExcel = null;
                
                // 关闭 WebSocket 连接
                // 移除ws客户端相关的connectWebSocket、wsClient等实现
                try {
                    // 获取桌面路径
                    const desktopPath = getDesktopPath();
                    const excelFilePath = path.join(desktopPath, fileName);
                    
                    // 检查文件是否存在
                    if (!fs.existsSync(excelFilePath)) {
                        sendToWebSocket('未找到excel文件，请确保文件在桌面上');
                        return;
                    }
            
                    // 读取Excel文件
                    const workbook = XLSX.readFile(excelFilePath);
                    const sheetName = workbook.SheetNames[0]; // 获取第一个工作表
                    const worksheet = workbook.Sheets[sheetName];
                    
                    // 将工作表转换为JSON数组
                    const jsonData = XLSX.utils.sheet_to_json(worksheet, { header: 1 });
                    
                    if (jsonData.length < 2) {
                        sendToWebSocket('Excel文件数据不足，至少需要表头和一行数据');
                        return;
                    }
            
                    // 获取表头行
                    const headers = jsonData[0] as string[];
                    const dataRows = jsonData.slice(1) as any[][];
            
                    // 查找列索引
                    const timeIndex = headers.findIndex(h => h === '时间');
                    const speedIndex = headers.findIndex(h => h === '速度');
                    const signalIndex = headers.findIndex(h => h === '信号');
                    const positionIndex = headers.findIndex(h => h === '位置');
                    const mileageIndex = headers.findIndex(h => h === '里程数值');
            
                    // 检查必需的列是否存在
                    const missingColumns = [];
                    if (timeIndex === -1) missingColumns.push('时间');
                    if (speedIndex === -1) missingColumns.push('速度');
                    if (signalIndex === -1) missingColumns.push('信号');
                    if (positionIndex === -1) missingColumns.push('位置');
                    if (mileageIndex === -1) missingColumns.push('里程数值');
            
                    if (missingColumns.length > 0) {
                        sendToWebSocket(`Excel文件缺少必需的列: ${missingColumns.join(', ')}`);
                        return;
                    }
            
                    // 转换数据
                    const result = dataRows.map((row, index) => {
                        return {
                            time: row[timeIndex] || '',
                            speed: row[speedIndex] || '',
                            signal: row[signalIndex] || '',
                            position: row[positionIndex] || '',
                            mileageLabel: row[mileageIndex] || ''
                        };
                    }).filter(item => 
                        // 过滤掉完全空的行
                        item.time !== '' || item.speed !== '' || item.signal !== '' || 
                        item.position !== '' || item.mileageLabel !== ''
                    );
            
                    sendToWebSocket(`Excel文件解析成功，共解析 ${result.length} 条数据`);
                    // 返回解析结果
                    res.json({
                        success: true,
                        message: 'Excel文件解析成功',
                        data: result,
                        total: result.length
                    });
            
                } catch (error) {
                    console.error('解析Excel文件失败:', error);
                    sendToWebSocket(`解析Excel文件失败: ${error instanceof Error ? error.message : '未知错误'}`);
                }
            });
    
            // 处理启动错误
            pythonProcessExcel.on('error', (error) => {
                console.error('启动 Python 进程失败:', error);
                sendToWebSocket(`启动 Python 进程失败: ${error.message}`);
                res.status(500).json({
                    success: false,
                    message: '启动检测失败',
                    error: error.message
                });
            });
        } catch (error) {
            res.status(500).json({
                success: false,
                message: '启动检测失败',
                error: error instanceof Error ? error.message : '未知错误'
            });
        }
    } catch (error) {
        // 处理文件大小超限错误
        if (error instanceof multer.MulterError) {
            if (error.code === 'LIMIT_FILE_SIZE') {
                return res.status(413).json({
                    success: false,
                    message: '文件大小超过限制',
                    error: '文件大小不能超过10GB'
                });
            }
        }
        
        res.status(500).json({
            success: false,
            message: '文件上传失败',
            error: error instanceof Error ? error.message : '未知错误'
        });
    }
});

export default router; 